GermanWikipedia - /page/entry.mu

Micron Document

<!DOCTYPE html>

<title>Template (C++)</title>

</head>

<h1 id="firstHeading" class="firstHeading mw-first-heading">Template (C++)</h1>

</header>

</div>

<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="de" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="de" dir="ltr">Templates (englisch für Schablonen oder Vorlagen) sind ein Mittel zur Typ<a href="Parameter_(Informatik)" title="Parameter (Informatik)">parametrierung</a> in <a href="C%2B%2B" title="C++">C++</a>. Templates ermöglichen <a href="Generische_Programmierung" title="Generische Programmierung">generische Programmierung</a> und <a href="Typsicherheit" title="Typsicherheit">typsichere</a> Container.

In der <a href="C%2B%2B-Standardbibliothek" title="C++-Standardbibliothek">C++-Standardbibliothek</a> werden Templates zur Bereitstellung typsicherer Container, wie z. B. Listen, und zur Implementierung von generischen Algorithmen, wie z. B. <a href="Sortierverfahren" title="Sortierverfahren">Sortierverfahren</a>, verwendet. Die Templates in C++ sind wesentlich von den parametrierbaren Modulen in <a href="CLU_(Programmiersprache)" title="CLU (Programmiersprache)">CLU</a> und den Generics in <a href="Ada_(Programmiersprache)" title="Ada (Programmiersprache)">Ada</a> inspiriert.<a href="#cite_note-Stroustrup-1">[1]</a>

In anderen Programmiersprachen (z. B. <a href="Java_(Programmiersprache)" title="Java (Programmiersprache)">Java</a><a href="#cite_note-2">[2]</a> oder <a href="C_Sharp" class="mw-redirect" title="C Sharp">C#</a><a href="#cite_note-3">[3]</a>) gibt es das Konzept des <a href="Generischer_Typ" title="Generischer Typ">generischen Typs</a>, das mit Templates verwandt ist. Generische Typen stellen jedoch keine <a href="Codegenerator" title="Codegenerator">Codegeneratoren</a> dar, sondern ermöglichen lediglich typsichere Container und Algorithmen.

<div class="mw-heading mw-heading2"><h2 id="Arten_von_Templates">Arten von Templates</h2></div>

Es gibt in C++ drei Arten von Templates: Funktions-Templates, Klassen-Templates und Variablen-Templates:

<div class="mw-heading mw-heading3"><h3 id="Funktions-Templates">Funktions-Templates</h3></div>

Ein Funktions-Template (auch fälschlich Template-Funktion genannt) verhält sich wie eine Funktion, die Argumente verschiedener Typen akzeptiert oder unterschiedliche Rückgabetypen liefert. Die C++-Standardbibliothek enthält beispielsweise das Funktions-Template <code>std::max(x, y)</code>, welches das größere der beiden Argumente zurückgibt. Es könnte etwa folgendermaßen definiert sein:

T max(T x, T y) {

T value;

if (x < y)

value = y;

else

value = x;

return value;

}

</pre></div>

Dieses Template kann genauso aufgerufen werden wie eine Funktion:

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>cout << max(3, 7); // gibt 7 aus

</pre></div>

Anhand der Argumente entscheidet der Compiler, dass es sich um einen Aufruf an <code>max(int, int)</code> handelt, und erzeugt eine Variante der Funktion, bei der der generische Typ T zu int festgelegt wird.

Der Template-Parameter könnte auch explizit angegeben werden:

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>cout << max<int>(3, 7); // gibt ebenfalls "7" aus

</pre></div>

Das Funktions-Template <code>max()</code> lässt sich für jeden Typ instanziieren, für den der Vergleich <code>x < y</code> eine wohldefinierte Operation darstellt. Bei selbstdefinierten Typen macht man von Operator-<a href="%C3%9Cberladen" title="Überladen">Überladung</a> Gebrauch, um die Bedeutung von <code><</code> für den Typ festzulegen und dadurch die Verwendung von <code>max()</code> für den betreffenden Typ zu ermöglichen.

Im Zusammenspiel mit der C++-Standardbibliothek erschließt sich eine enorme Funktionalität für selbstdefinierte Typen durch Definition einiger Operatoren. Allein durch die Definition eines Vergleichsoperators <code><</code> (<a href="Strenge_schwache_Ordnung" title="Strenge schwache Ordnung">strenge schwache Ordnung</a>) werden die Standardalgorithmen <code>std::sort()</code>, <code>std::stable_sort()</code>, und <code>std::binary_search()</code> für den selbstdefinierten Typ anwendbar.

<div class="mw-heading mw-heading3"><h3 id="Klassen-Templates">Klassen-Templates</h3></div>

Ein Klassen-Template (deutsch: Klassenvorlage, auch fälschlich Template-Klasse genannt), wendet das gleiche Prinzip auf Klassen an. Klassen-Templates werden oft zur Erstellung von generischen Containern verwendet. Beispielsweise enthält die C++-Standardbibliothek einen Container, der eine verkettete Liste implementiert. Um eine verkettete Liste von int zu erstellen, schreibt man <code>std::list<int></code>. Eine verkettete Liste von Objekten des Datentypes <code>std::string</code> wird zu <code>std::list<std::string></code>. Mit list ist ein Satz von Standardfunktionen definiert, die immer verfügbar sind, unabhängig davon, was man als Argumenttyp in den spitzen Klammern angibt. Die Werte in spitzen Klammern werden Parameter genannt. Wenn ein Klassen-Template mit seinen Parametern dem Compiler übergeben wird, so kann dieser das Template ausprägen. Er erzeugt hierbei zu jedem Parametertyp eine eigene Template-Klasse. Diese ist eine gewöhnliche Klasse, wie jede andere auch. Die Begriffe Klassen-Template und Template-Klasse sind hier voneinander zu unterscheiden. Wie Objekt und Klasse ist die Template-Klasse eine Ausprägung eines Klassen-Templates.

Templates sind sowohl für mit class als auch für mit struct und union definierte Klassen anwendbar. Namespaces (deutsch: Namensräume) lassen sich dagegen nicht als Template anlegen. Eine Möglichkeit, Typ-Definitionen per „typedef“ als Templates anzulegen, kam mit C++11 hinzu.

<div class="mw-heading mw-heading4"><h4 id="Vererbung">Vererbung</h4></div>

Klassen-Templates können wie normale Klassen in Vererbungshierarchien sowohl als Basis- als auch als abgeleitete Klasse auftreten.

Wird ein Klassen-Template mit verschiedenen Klassenparametern ausgeprägt, so stehen diese grundsätzlich in keiner Vererbungsrelation – auch nicht, wenn die Template-Parameter in einer Vererbungsbeziehung stehen.

<dl><dt>Beispiel</dt>

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>class Base {...};

class Derived: Base { ... };

Base* b = new Derived; // OK. Automatische Typumwandlung, da Basisklasse.

std::vector<Base>* vb = new std::vector<Derived>; // FEHLER!

</pre></div>

Es gibt vor allem zwei Gründe, wieso derartige Umwandlungen nicht erlaubt sind:

Zum einen sind es technische Gründe: Ein <code>std::vector<T></code> speichert seine Elemente in einem Array an unmittelbar aufeinander folgenden Adressen. Wenn nun ein Objekt vom Typ <code>Derived</code> eine andere Größe hat als ein Objekt vom Typ <code>Base</code>, dann stimmt das Speicherlayout von einem <code>std::vector<Base></code> nicht mehr mit dem eines <code>std::vector<Derived></code> überein und der Zugriff auf die Elemente würde fehlschlagen.

Zum anderen hat es aber auch programmlogische Gründe: Ein Container, der Elemente einer Basisklasse enthält, verweist auf Elemente, deren Datentyp <code>Base</code> ist oder von <code>Base</code> abgeleitet sind. Er ist somit einerseits mächtiger als ein Container, der nur Elemente vom Typ <code>Derived</code> aufnehmen kann, andererseits weniger mächtig, da er nur garantiert Elemente vom Type <code>Base</code> zurückzugeben.

Für <code>std::vector<T></code> illustriert das am einfachsten der <code>[]</code> operator.

<dl><dt>Beispiel</dt>

Base * b = new Base;

Derived* d = new Derived;

std::vector<Base> * vb = new std::vector<Base>;

std::vector<Derived>* vd = new std::vector<Derived>;

</pre></div>

Einerseits kann man <code>vb[0] = b</code> nicht aber <code>vd[0] = b</code> schreiben.

Andererseits kann man <code>d = vd[0]</code> nicht aber <code>d = vb[0]</code> schreiben.

Falls eine Umwandlung von verschiedenen Ausprägungen desselben Klassen-Templates – wie etwa bei <code>std::shared_ptr</code> – sinnvoll ist, muss dafür explizit ein Typkonvertierungsoperator definiert werden.

<div class="mw-heading mw-heading3"><h3 id="Variablen-Templates">Variablen-Templates</h3></div>

Seit C++14 ist es auch möglich, Variablen-Templates zu definieren. Das ermöglicht es, Variablen, die logisch zusammen gehören bzw. bis auf den Typ „dasselbe“ sind, entsprechend kenntlich zu machen:

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>// variable template

template<class T>

constexpr T Pi = T(3.1415926535897932385L);

// function template

template<class T>

T kreisflaeche(T r) {

return Pi<T> * r * r;

}

</pre></div>

Die Funktion <code>kreisflaeche()</code> kann nun für verschiedene arithmetische Datentypen instanziiert werden und greift dabei stets auf eine vom Parametertyp her passende Konstante <code>Pi</code> zu.

<div class="mw-heading mw-heading2"><h2 id="Spezialisierung">Spezialisierung</h2></div>

Templates lassen sich spezialisieren, d. h., man kann Klassen- und Funktions-Templates (für bestimmte Datentypen als Template-Argumente) gesondert implementieren. Dies erlaubt eine effizientere Implementierung für bestimmte ausgewählte Datentypen, ohne die Schnittstelle des Templates zu verändern. Davon machen auch viele Implementierungen der C++-Standardbibliothek (beispielsweise die der <a href="GNU_Compiler_Collection" title="GNU Compiler Collection">GCC</a>) Gebrauch.

<div class="mw-heading mw-heading3"><h3 id="Spezialisierung_bei_Klassen-Templates">Spezialisierung bei Klassen-Templates</h3></div>

Die Containerklasse <code>std::vector</code> der C++-Standardbibliothek kann für den Elementtyp bool als Bitmap implementiert werden, um Speicherplatz einzusparen. Auch entnimmt das Klassen-Template <code>std::basic_string</code> die Informationen zum Umgang mit den einzelnen Zeichen der Struktur char_traits, die für den Datentyp char und beispielsweise auch wchar_t spezialisiert ist.

Die Deklaration von Spezialisierungen ähnelt der von normalen Templates. Allerdings sind die dem Schlüsselwort template folgenden spitzen Klammern leer, und dem Funktions- bzw. Klassennamen folgen die Template-Parameter.

<dl><dt>Beispiel</dt>

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>template<>

class vector<bool> {

// Implementierung von vector als Bitmap

};

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Partielle_Spezialisierung">Partielle Spezialisierung</h3></div>

Weiterhin gibt es auch die sogenannte partielle Spezialisierung, die die Behandlung von Spezialfällen innerhalb eines Templates ermöglicht.

<dl><dt>Beispiel</dt>

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>template<int zeilen, int spalten>

class Matrix {

// Implementierung einer Matrix-Klasse

};

template<int zeilen>

class Matrix<zeilen, 1> {

// Implementierung einer einspaltigen Matrix-Klasse

};

</pre></div>

Die Instanziierung läuft bei der spezialisierten Klasse im Grunde gleich ab, es wird nur der Code aus einem anderen Klassen-Template generiert, nämlich der Spezialisierung:

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>int main() {

// erste Klasse

Matrix<3,3> a;

// teilweise spezialisiertes Klassen-Template (zweite Klasse)

Matrix<15,1> b;

}

</pre></div>

Wichtig zu erwähnen ist, dass beide Klassen voneinander unabhängig sind, d. h., sie erben weder <a href="Konstruktor" class="mw-redirect" title="Konstruktor">Konstruktoren</a> oder <a href="Destruktor" class="mw-redirect" title="Destruktor">Destruktoren</a> noch Elementfunktionen bzw. Datenelemente voneinander.

<div class="mw-heading mw-heading3"><h3 id="Spezialisierung_bei_Funktions-Templates">Spezialisierung bei Funktions-Templates</h3></div>

Im Unterschied zu Klassen-Templates sind Funktions-Templates laut Standard nicht teilweise spezialisierbar (nur vollständig). Allerdings wird von der Spezialisierung von Funktions-Templates allgemein abgeraten, da die Regeln für die Bestimmung der „am besten passenden“ Funktion sonst zu unintuitiven Ergebnissen führen können.<a href="#cite_note-4">[4]</a>

Durch Überladen von Funktions-Templates mit anderen Funktions-Templates kann man in den meisten Fällen das Gleiche erreichen wie durch die (nicht zulässige) teilweise Spezialisierung. Die Erweiterung selbst läuft gewöhnlich sehr intuitiv ab:

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>// Generische Funktion

template<class T, class U>

void f(T a, U b) {}

// Überladenes Funktions-Template

template<class T>

void f(T a, int b) {}

// Vollständig spezialisiert; immer noch Template

template<>

void f(int a, int b) {}

</pre></div>

Hierbei muss allerdings beachtet werden, dass ein expliziter Aufruf wie <code>f<int,int>()</code> nicht zum gewünschten Ergebnis führt. Dieser Aufruf würde die generische Funktion statt der voll spezialisierten aufrufen. Ein Aufruf von <code>f<int>()</code> hingegen ruft nicht die erste überladene Template-Funktion auf, sondern die voll spezialisierte. Unterlässt man explizite Aufrufe, funktioniert normalerweise alles, wie es logisch scheint (<code>f(3, 3)</code> ruft die voll spezialisierte Funktion auf, <code>f(3.5, 5)</code> die teilweise spezialisierte (erste überladene Funktion) und <code>f(3.5, 2.0)</code> die generische). Mit dieser Art der Spezialisierung sollte man also vorsichtig sein und, wenn möglich, gleich vollständig spezialisieren.

Falls diese Technik aus jedwedem Grund im konkreten Fall nicht anwendbar ist – z. B. wenn ein Template von Klassenmethoden spezialisiert werden soll, ohne die Klassendefinition zu erweitern – so kann man auch das Problem der Spezialisierung auf ein Template einer Hilfsklasse verlagern:

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>class Example {

private:

template<typename T>

struct Frobnicator {

static T do_frobnicate(T param);

};

public:

template<typename T>

T frobnicate(T param);

};

template<typename T>

T Example::frobnicate(T param) {

// Frobnicator soll die eigentliche Arbeit verrichten

return Frobnicator<T>::do_frobnicate(param);

}

template<typename T>

T Example::Frobnicator<T>::do_frobnicate(T param) {

// Standardimplementierung ...

}

template<>

int Example::Frobnicator<int>::do_frobnicate(int param) {

// ints werden auf andere Weise "frobnifiziert"

return (param << 3) + (param % 7) - param + foobar;

}

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Template-Parameter">Template-Parameter</h2></div>

Templates können vier Arten von Parametern haben: Typparameter, Nichttyp-Parameter, Template-Parameter und sogenannte Parameter-Packs, mit denen Templates mit einer variablen Anzahl von Parametern definiert werden können.

<div class="mw-heading mw-heading3"><h3 id="Typ-Parameter">Typ-Parameter</h3></div>

Templates mit Typ-Parametern entsprechen in etwa den generischen Typen anderer Programmiersprachen. Als Typ-Parameter kann jeder beliebige Datentyp verwendet werden, wobei je nach Verwendung des Typ-Parameters innerhalb des Templates die Menge der Parametertypen, mit denen das Template instanziiert werden kann, beschränkt ist.

Die Container der C++-Standardbibliothek verwenden unter anderem Typ-Parameter, um für alle Datentypen, auch benutzerdefinierte, geeignete Container zur Verfügung zu stellen.

class Vector {

public:

Vector(): rep(0) {}

Vector(int _size): rep(new T[_size]), size(_size) {}

~Vector() { delete[] rep; }

private:

T* rep;

int size;

};

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Nichttyp-Parameter">Nichttyp-Parameter</h3></div>

Nichttyp-Parameter (engl. non-type template parameter) sind konstante, zur Übersetzungszeit bekannte, Werte, mit denen Größen, Verfahren oder Prädikate als Template-Parameter übergeben werden können. Als Nichttyp-Template-Parameter sind erlaubt:

<ul><li>ganzzahlige Konstanten (inklusive Zeichenkonstanten),</li>

<li>Zeigerkonstanten (Daten- und Funktionszeiger, inklusive Zeiger auf Member-Variablen und -Funktionen) und</li>

<li>Zeichenkettenkonstanten.</li></ul>

Verwendung finden Nichttyp-Parametern z. B. als Größenangabe bei <code>std::array</code> oder als Sortier- und Suchkriterium bei vielen Algorithmen der Standardbibliothek, wie z. B. <code>std::sort</code>, <code>std::find_if</code> oder <code>std::for_each</code>.

<div class="mw-heading mw-heading3"><h3 id="Template-Templates">Template-Templates</h3></div>

Als Template-Templates werden Konstruktionen bezeichnet, bei denen Templates wiederum Templates als Parameter übernehmen. Sie stellen einen weiteren Abstraktionsmechanismus zur Verfügung. Im folgenden Beispiel wird sowohl der Typ als auch der verwendete Container angegeben; letzterer mit Hilfe eines Template-Template-Parameters:

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>template <template <typename, typename> class Container, typename Type>

class Example {

Container<Type, std::allocator <Type> > baz;

};

</pre></div>

Beispiel zur Verwendung:

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>Example <std::deque, int> example;

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Parameter-Packs">Parameter-Packs</h3></div>

Seit C++11 gibt es die Möglichkeit, Templates mit variabler Anzahl von Template-Parametern zu definieren. Diese werden – wie bei Funktionen und Makros mit variabler Parameteranzahl – mit <code>...</code> gekennzeichnet:

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>template<typename... Values> class tuple {

// Definition ausgelassen

};

// Verwendung:

tuple<int, int, char, std::vector<int>, double> t;

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Siehe_auch">Siehe auch</h2></div>

<ul><li><a href="C%2B%2B-Metaprogrammierung" title="C++-Metaprogrammierung">C++-Metaprogrammierung</a></li>

<li><a href="Duck-Typing" title="Duck-Typing">Duck-Typing</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="Literatur">Literatur</h2></div>

<ul><li>David Vandervoorde, Nicolai M. Josuttis: <cite style="font-style:italic">C++ Templates</cite>. The Complete Guide. Addison-Wesley Professional, 2003, ISBN 0-201-73484-2.<span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rfr_id=info:sid/de.wikipedia.org:Template+%28C%2B%2B%29&rft.au=David+Vandervoorde%2C+Nicolai+M.+Josuttis&rft.btitle=C%2B%2B+Templates&rft.date=2003&rft.genre=book&rft.isbn=0201734842&rft.pub=Addison-Wesley+Professional" style="display:none"> </li></ul>

<div class="mw-heading mw-heading2"><h2 id="Einzelnachweise">Einzelnachweise</h2></div>

<li id="cite_note-Stroustrup-1"><a href="#cite_ref-Stroustrup_1-0">↑</a> <a href="Bjarne_Stroustrup" title="Bjarne Stroustrup">Bjarne Stroustrup</a>: <cite style="font-style:italic">Die C++-Programmiersprache</cite>. 4. Auflage. Addison-Wesley, 2009, ISBN 978-3-8273-2823-6.<span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&rfr_id=info:sid/de.wikipedia.org:Template+%28C%2B%2B%29&rft.au=Bjarne+Stroustrup&rft.btitle=Die+C%2B%2B-Programmiersprache&rft.date=2009&rft.edition=4.&rft.genre=book&rft.isbn=9783827328236&rft.pub=Addison-Wesley" style="display:none">

</li>

<li id="cite_note-2"><a href="#cite_ref-2">↑</a> <a rel="nofollow" class="external text" href="http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf">Oracle Technology Network for Java Developers | Oracle Technology Network | Oracle.</a> (PDF) Abgerufen am 26. Mai 2017.<span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3ATemplate+%28C%2B%2B%29&rft.title=Oracle+Technology+Network+for+Java+Developers+%7C+Oracle+Technology+Network+%7C+Oracle&rft.description=Oracle+Technology+Network+for+Java+Developers+%7C+Oracle+Technology+Network+%7C+Oracle&rft.identifier=http%3A%2F%2Fjava.sun.com%2Fj2se%2F1.5%2Fpdf%2Fgenerics-tutorial.pdf">

</li>

<li id="cite_note-3"><a href="#cite_ref-3">↑</a> <a rel="nofollow" class="external text" href="http://msdn.microsoft.com/en-us/library/ms379564(VS.80).aspx">An Introduction to C# Generics.</a> Abgerufen am 26. Mai 2017 (englisch).<span style="display: none;" class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Adc&rfr_id=info%3Asid%2Fde.wikipedia.org%3ATemplate+%28C%2B%2B%29&rft.title=An+Introduction+to+C%23+Generics&rft.description=An+Introduction+to+C%23+Generics&rft.identifier=http%3A%2F%2Fmsdn.microsoft.com%2Fen-us%2Flibrary%2Fms379564%28VS.80%29.aspx&rft.language=en">

</li>

<li id="cite_note-4"><a href="#cite_ref-4">↑</a> Herb Sutter: <cite style="font-style:italic">Why Not Specialize Function Templates?</cite> In: <cite style="font-style:italic">C/C++ Users Journal</cite>. Band 7, Nr. 19, Juli 2001 (<a rel="nofollow" class="external text" href="http://www.gotw.ca/publications/mill17.htm">gotw.ca</a>).<span class="Z3988" title="ctx_ver=Z39.88-2004&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&rfr_id=info:sid/de.wikipedia.org:Template+%28C%2B%2B%29&rft.atitle=Why+Not+Specialize+Function+Templates%3F&rft.au=Herb+Sutter&rft.date=2001-07&rft.genre=journal&rft.issue=19&rft.jtitle=C%2FC%2B%2B+Users+Journal&rft.volume=7" style="display:none">

</li>

</ol></div><div><div class="zim-footer">

Dieser Artikel wurde von <a class="external text" title="Zuletzt bearbeitet am 2025-10-16" href="https://de.wikipedia.org/wiki/?title=Template_(C%2B%2B)&oldid=260639873">Wikipedia</a> herausgegeben. Der Text ist unter <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.de">Creative Commons Attribution-Share Alike 4.0</a> verfügbar, sofern nicht anders angegeben. Für die Mediendateien können zusätzliche Bedingungen gelten.

</div>

</div></div>

</div>

</main>

</div>

</body></html>